/*+----------+--------------------------------------------------+----------+
  + 19/06/98 +             EIC.h                                + Ver 1.00 +
  +----------+--------------------------------------------------+----------+
  +                                                                        +
  +    Ce fichier déclare les fonctions, types et identificateurs de       +
  + ressources usuels EIC.   (gvfdgvdfgdf)                                 +
  +------------------------------------------------------------------------+*/
#ifndef EICH
#define EICH

#ifdef _EIC_BPL
  #define PACKAGE_EIC __declspec( dllexport)
#else
  #define PACKAGE_EIC __declspec( dllimport)
#endif

#include <system.hpp>
#include <DString.h>
#include <Controls.hpp>
#include <Forms.hpp>
#include <Graphics.hpp>
#include "values.h"
#include "uBarre.h"
#include "EICRes.h" // Identificateurs des Ressources standard d'EIC

extern PACKAGE_EIC void       __fastcall Assert( unsigned long ulLineNb, const char* pcszSourceFile,const char* Fonction = "");

#ifdef _DEBUG
 #ifdef NDEBUG
  #error Problème de définition: _DEBUG et NDEBUG ne peuvent pas être définis simultanément...
 #endif
 #pragma option -xp+   // Active les informations sur l'emplacement des exceptions
 #pragma option -w-ccc // Désactivation du warning "Condition is always true." pour les ASSERT constants
 #include <assert.h>
 #include <String.h>   // Pour ASSERT_VALID_STRING
  extern PACKAGE_EIC bool       __fastcall IsMachine(const AnsiString &Nom = EmptyStr);
  extern PACKAGE_EIC AnsiString __fastcall EICComponentName( TComponent* pComp);
    // Affiche un message ds l'historique d'événements
  extern void __cdecl PACKAGE_EIC TRACE( const char* szFormat, ...);
  extern void PACKAGE_EIC TRACE( const AnsiString& asFormat, const TVarRec *args, int size);
  extern void PACKAGE_EIC _AfficheLastError( unsigned long ulLineNb, const char* pcszSourceFile,const char* Fonction, const AnsiString &Titre = EmptyStr, const AnsiString &Message = EmptyStr);
 #define AfficheLastError( )                     _AfficheLastError( __LINE__, __FILE__,__FUNC__)
 #define AfficheLastErrorT( Titre)               _AfficheLastError( __LINE__, __FILE__,__FUNC__, Titre)
 #define AfficheLastErrorM( Message)             _AfficheLastError( __LINE__, __FILE__,__FUNC__, EmptyStr, Message)
 #define AfficheLastErrorTM( Titre, Message)     _AfficheLastError( __LINE__, __FILE__,__FUNC__, Titre, Message)
 #define ASSERT( TEST)                           ( (TEST)? (void)0 : Assert( __LINE__, __FILE__,__FUNC__))
 #define ASSERT_VALID( pClassInstance)           (pClassInstance)->AssertValid()
 #define ASSERT_VALID_STRING( szBUF)             ASSERT( strlen( szBUF) < sizeof( szBUF))
 #define VERIFY( EXPRESSION)                     ASSERT( (EXPRESSION))
 #define IS_MACHINE( sNom)                       IsMachine(sNom)
 #define IS_MACHINE_INFORMATICIEN()              IsMachine()
 #define IS_MACHINE_TEST()                       !IsMachine()
#else
 #pragma option -xp- // Désactive les informations sur l'emplacement des exceptions

 #define NDEBUG
 #define ASSERT( TEST)
 #define ASSERT_VALID( pClassInstance)
 #define ASSERT_VALID_STRING( szBUF)
 #define VERIFY( EXPRESSION)                     EXPRESSION
 #define TRACE
 #define AfficheLastError( )
 #define AfficheLastErrorT( Titre)
 #define AfficheLastErrorM( Message)
 #define AfficheLastErrorTM( Titre, Message)
#endif


// Gestion des tag //
/* Pour marquer une opération, MODULE_TAG doit être défini dans le module */
/* MODULE_TAG doit pouvoir être codé sur 16 bits et le numéro sur 16 bits */
typedef unsigned long EICTag;
#define TAG( N)          (EICTag)(((((EICTag)(MODULE_TAG))&0x0000FFFF)<<16)|(((EICTag)(N))&0x0000FFFF))
#define TAG_MODULE( TAG) (unsigned short)(((EICTag)(TAG))>>16)
#define TAG_TAG( TAG)    (unsigned short)((EICTag)(TAG))
#define TAGL TAG(__LINE__)

#define fieldsize( s, f) sizeof( ((s*)0)->f)

// Valeurs non définies des différents types de donnée
#define SH_NS   SHRT_MIN
#define USH_NS  USHRT_MAX
#define I_NS    (-MAXLONG)
#define L_NS    (-MAXLONG)
#define UI_NS   UINT_MAX
#define F_NS    -MAXFLOAT
#define D_NS    -MAXDOUBLE

#define EIC_INIT_FORMATS() Application->UpdateFormatSettings = false; /* Empêche la modif des formats de date et d'heure */ \
                           /* Initialisation des formats de date */                     \
                           DateSeparator   = '/';                                       \
                           ShortDateFormat = "dd/mm/yyyy";                              \
                           TimeSeparator   = ':';                                       \
                           ShortTimeFormat = "hh:nn";                                   \
                           /* Initialisation du format monétaire */                     \
                           CurrencyString    = EmptyStr; /* Pas de symbole monétaire */ \
                           /*CurrencyFormat    = 3;        /* 1 F */                      \
                           /*NegCurrFormat     = 8;        /* -1 F */                     \
                           /*ThousandSeparator = ' ';      /* 1 000 F */                  \
                           /*DecimalSeparator  = ',';      /* 1.00 F */                   \
                           //CurrencyDecimals  = NB_DECIMALES_DEFAUT

#define GENERATE_OLD_ONCREATE( Ancestor)     virtual void __fastcall ReadState( TReader *pReader) { Ancestor::ReadState( pReader); OldCreateOrder=false; }
#define GENERATE_OLD_ONCREATE_TFORM()        GENERATE_OLD_ONCREATE( TForm       )
#define GENERATE_OLD_ONCREATE_CFORM()        GENERATE_OLD_ONCREATE( CForm       )
#define GENERATE_OLD_ONCREATE_CMAINFORM()    GENERATE_OLD_ONCREATE( CEICMainForm)
#define GENERATE_OLD_ONCREATE_TDATAMODULE()  GENERATE_OLD_ONCREATE( TDataModule )


#define VER_DLL_INCONNUE "Inconnue" //Utilisé par GetDLLVer lorsque la version est inconnue
#define EXTRAIRE_CH(Chaine, NoDebut, NoFin) Chaine.SubString (NoDebut, NoFin-(NoDebut)+1)
#define EIC_BSTR(Chaine) WideString(Chaine).c_bstr()

// Platforme connu
enum VER_PLATFORM {
  VP_UNKNOWN,
  VP_WINDOWS_95_98,
  VP_WINDOWS_NT
};



enum eWindows
{
  eWinInconnu = 0,
  eWin95,
  eWin98,
  eWinMe,
  eWinNT351,
  eWinNT40,
  eWin2000,
  eWinXP,
  eWinNETServer,
  eWinVista,
};

extern eWindows PACKAGE_EIC __fastcall GetVersionDeWindows();
extern int PACKAGE_EIC __fastcall GetVersionDeServicePack();

/*extern bool PACKAGE_EIC __fastcall PosteTSE();  */



// Actions envoyées à un assistant 32bits
enum RUN_ACTION {
  RA_START = 0,
  RA_EXIT
};


// Code pays
enum CODE_PAYS {
  CP_FRANCE = 0,
  CP_TUNISIE
};


// Définition des ressources standard EIC //
#define RESOURCE_STD_MIN 32000
#define RESOURCE_STD_MAX 32499
#define IS_RESOURCE_STD( nID) ( ( ((int)(nID)) >= RESOURCE_STD_MIN ) && ( ((int)(nID)) <= RESOURCE_STD_MAX ) )

// Ressources Bitmap
// => Visas (3 visas possibles d'un compte ou d'un programme de travail)
#define STDIDB_VISAS_WIDTH  18
#define STDIDB_VISAS_HEIGHT 13

#define STDIDB_VISA_AUCUN                    -1  // Aucun visa
#define STDIDB_VISA_ORDINAIRE_ON              0  // Visa cycle ordinaire positionné
#define STDIDB_VISA_ORDINAIRE_ON_FINAL_OFF    1  //   "    "       "         "      et cycle final non positionné
#define STDIDB_VISA_ORDINAIRE_ONOFF_FINAL_ON  2  //   "    "       "     quelconque "    "     "     positionné

#define STDIDB_VISA_OFF                       STDIDB_VISA_AUCUN
#define STDIDB_VISA_ON                        STDIDB_VISA_ORDINAIRE_ON

#define STDIDB_VISA_FIRST                     STDIDB_VISA_ORDINAIRE_ON
#define STDIDB_VISA_LAST                      STDIDB_VISA_ORDINAIRE_ONOFF_FINAL_ON

#define ARROW_DOWN                            0
#define ARROW_UP                              1


extern PACKAGE_EIC VER_PLATFORM _WINPLATFORM;   // Type de la platform dans lequel l'appli évolue
extern PACKAGE_EIC int _SERVICE_PACK;   // Service pack du système d'exploitation dans lequel l'appli évolue
extern PACKAGE_EIC AnsiString   _ComputerName;  // Nom de la machine

// Variables du mulot à roulette //
//extern PACKAGE_EIC unsigned int _WM_MOUSEWHEEL; // numero du message du mulot à roue
//extern PACKAGE_EIC          int _b3DSupport;    // contains returned flag for wheel support active
//extern PACKAGE_EIC          int _nScrollLines;  // contains returned scroll lines

enum CodesPartenaires
{
  ecp_EIC = 0,
  ecp_Fiduciaire_DR,
  ecp_Fiduciaire_TP,
};
extern PACKAGE_EIC enum CodesPartenaires _CodePartenaire;
extern PACKAGE_EIC CODE_PAYS    _CodePays;      // détermine le mode de fonctionnement du MenuFed selon le pays
extern PACKAGE_EIC bool         _MoveFile;      // _MoveFile=true utilisé la fonction API pour déplacer des répertoires
                                            // au lieu de la fonction à David qui provoque des messages d'erreurs chez
                                            // certains clients (ex: fiche 189 avec Win95 4.00.950)
extern PACKAGE_EIC bool _SignatureElectronique;

extern PACKAGE_EIC HWND hwndFenetreEICShell;
extern PACKAGE_EIC void __fastcall EmpilerFenetre(HWND Handle);
extern PACKAGE_EIC void __fastcall DepilerFenetre(HWND Handle);

extern PACKAGE_EIC AnsiString __fastcall EICCharToOem( const AnsiString &strVal);
extern PACKAGE_EIC AnsiString __fastcall EICOemToChar( const AnsiString &strVal);
extern PACKAGE_EIC AnsiString __fastcall EICResStr( const char* pcszIDS);
inline         AnsiString __fastcall EICResStr( UINT uIDS) { return( EICResStr( MAKEINTRESOURCE( uIDS)));};
extern PACKAGE_EIC AnsiString __cdecl    EICFormat( const char* pcszFormat, ...);

extern PACKAGE_EIC void 	  __fastcall GetFileVersionInfos( const AnsiString &FullFileName, TStringList *LInfos );
extern PACKAGE_EIC AnsiString __fastcall GetDLLVer(const AnsiString &aDLLName); //Donne la version chaîne d'une dll
extern PACKAGE_EIC __int64 __fastcall GetNumeriqueDLLVer(const AnsiString &aDLLName); //Donne la version numérique d'une dll

// Messages standard //
extern PACKAGE_EIC UINT __fastcall EICMsgBox( const char* pcszMsg,
                                          const char* pcszTitre,
                                          UINT        uType      // MB_APPLMODAL | MB_SETFOREGROUND automatiques
                                        );    // Choix de l'utilisateur
extern PACKAGE_EIC UINT __fastcall EICMsgBox(const AnsiString &ChaineMessage,const AnsiString &ChaineTitre,UINT uType);
extern PACKAGE_EIC bool __fastcall EICQuestion( const char* pcszQuestion,
                                            const char* pcszTitre,
                                            UINT        uType = 0     // MB_ICONQUESTION | MB_YESNO | MB_APPLMODAL | MB_SETFOREGROUND automatiques
                                          );  // TRUE si utilisateur choisi IDOK
extern PACKAGE_EIC bool __fastcall EICQuestion(const AnsiString &ChaineMessage,const AnsiString &ChaineTitre,UINT uType = 0);
extern PACKAGE_EIC bool __fastcall EICOkAnnuler( const char* pcszQuestion,
                                            const char* pcszTitre,
                                            UINT        uType = 0     // MB_ICONQUESTION | MB_YESNO | MB_APPLMODAL | MB_SETFOREGROUND automatiques
                                          );  // TRUE si utilisateur choisi IDOK
extern PACKAGE_EIC bool __fastcall EICOkAnnuler(const AnsiString &ChaineMessage,const AnsiString &ChaineTitre,UINT uType = 0);
extern PACKAGE_EIC bool __fastcall EICErreur( const char* pcszErrMsg);// ( MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL | MB_SETFOREGROUND) // TRUE si idsErr != 0
extern PACKAGE_EIC bool __fastcall EICErreur(const AnsiString &ChaineMessage);
extern PACKAGE_EIC void __fastcall EICAttention( const char* pcszMsg);
extern PACKAGE_EIC void __fastcall EICAttention(const AnsiString &ChaineMessage);
extern PACKAGE_EIC void __fastcall EICInformation(const AnsiString &ChaineMessage);
extern PACKAGE_EIC bool __fastcall EICReessayer(const AnsiString &ChaineMessage,const AnsiString &ChaineTitre,UINT uType = 0);


inline bool __fastcall EICErreur( int idsErr)     { return( EICErreur( MAKEINTRESOURCE( idsErr)));}
inline void __fastcall EICAttention( int idsWarn) { EICAttention( MAKEINTRESOURCE( idsWarn));}

// Messages d'exception //
extern PACKAGE_EIC AnsiString __fastcall EICMessageException(EICTag tag,const Exception &e,void *hInstance = HInstance);
extern PACKAGE_EIC void __fastcall EICDisplayException( EICTag           tag,
                                                    const Exception& e,
                                                    void*            hInstance = HInstance); // ( MB_OK | MB_ICONSTOP | MB_APPLMODAL | MB_SETFOREGROUND)
extern PACKAGE_EIC void __fastcall EICDisplayException(const Exception &e,unsigned int Ligne,const AnsiString &Fichier,void *hInstance = HInstance);
#define EIC_DISPLAY_EXCEPTION(X) EICDisplayException(X,__LINE__,__FILE__)
extern PACKAGE_EIC void __fastcall EICDisplayExceptionMsg( const Exception& e,
                                                       const char*      pcszMsgIssue = NULL /*"Commande annulée"*/,
                                                       const char*      pcszTitre    = NULL /*"Anomalie d'exécution"*/,
                                                       void*            hInstance    = HInstance);                      // ( MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL | MB_SETFOREGROUND)


extern PACKAGE_EIC void __fastcall DrawVisa( TCanvas* pCanvas, const TRect& rect, int eStdIDVisa,bool Stretch = false);
extern PACKAGE_EIC void __fastcall DrawGridArrowUpDown( TCanvas *pCanvas, const TRect &rect, int nIDImg);



class PACKAGE_EIC CSablier
{
 private:
  bool    m_bWaiting;     // TRUE si le curseur "Attente de traitement" est actif
  static TList *m_ListeCursPrevious;  //Curseurs précédents
  static unsigned int m_nbCSablier;   //Nombre de sabliers lancés
 public:
  __fastcall CSablier();
  virtual __fastcall ~CSablier();
  void __fastcall Fin();
  void __fastcall Wait();
};



class PACKAGE_EIC CBarre
{
 private:
  TForm*     m_pfrmOwnerAndParent; // Fiche parente de la barre
  TfrmBarre*      m_pvfrmBarre;         // Fiche qui représente la barre (class TfrmBarre)
  AnsiString m_strTitre,m_strMessages;
  DWORD      m_dwMax,m_Position,m_dwMax2,m_Position2;
  bool m_DoubleAffichage,m_AfficherBoutonAnnuler;
  void __fastcall SetMessageInfo(int Index,const AnsiString& strMsgInfo);
  void __fastcall SetMax(int Index,DWORD dwMax);
  void __fastcall SetPosition(int Index,DWORD dwPosition);
  int  __fastcall GetCurrentMessage() const;
  HWND __fastcall GetHandle() const;
  void __fastcall SetDoubleAffichage(bool AfficherDeuxiemeBarre);
  void __fastcall SetAnnule(bool bAnnule);
  bool __fastcall GetAnnule() const;
  void __fastcall SetAfficherBoutonAnnuler(bool bAfficherBoutonAnnuler);
 public:
  __property AnsiString Titre          = { read = m_strTitre,    write = m_strTitre};
  __property AnsiString Messages       = { read = m_strMessages, write = m_strMessages};
  __property AnsiString MessageInfo    = {                       write = SetMessageInfo,index = 1};
  __property AnsiString MessageInfo2   = {                       write = SetMessageInfo,index = 2};
  __property DWORD      Max            = { read = m_dwMax,       write = SetMax,index = 1};
  __property DWORD      Max2           = { read = m_dwMax2,      write = SetMax,index = 2};
  __property DWORD      Position       = { read = m_Position,    write = SetPosition,index = 1};
  __property DWORD      Position2      = { read = m_Position2,   write = SetPosition,index = 2};
  __property int        CurrentMessage = { read=GetCurrentMessage};
  __property HWND Handle = {read = GetHandle};
  __property bool DoubleAffichage = {read = m_DoubleAffichage,write = SetDoubleAffichage};
  __property bool AfficherBoutonAnnuler = {read = m_AfficherBoutonAnnuler,write = SetAfficherBoutonAnnuler};
  __property bool Annule = {read = GetAnnule,write = SetAnnule};
  void __fastcall Open();
  void __fastcall Close();
  void __fastcall operator++();
  void __fastcall operator=( DWORD dwPos);
  void __fastcall NextMessage();
  void __fastcall Refresh() const;
  void __fastcall ChangerMax(DWORD dwMax);//Sans changer la position
  __fastcall CBarre(TForm* pfrmOwnerAndParent = NULL);
  virtual __fastcall ~CBarre();
}; /* class CBarre */
#pragma warn -pre // Désactive le message "Overloaded prefix 'operator ++' used as a postfix operator" pour permettre les opérations du type Barre++


// Types pour la gestion des fichiers
typedef void (__fastcall* ENUMPATTERN_CALLBACK)( const AnsiString& strFullFileName, bool& bContinueEnumeration, long lUserData);

// Définition des drapeaux possibles pour EICCopy
#define CF_DEFAULT       0x0000
#define CF_SHOW_BARRE    0x0001
#define CF_DEL_SOURCE    0x0002 // Eface le fichier source après copie
#define CF_NO_OVERWRITE  0x0004 // Interdit l'écrasement du fichier cible
#define CF_AFF_ERROR     0x0008
#define CF_BACKUP_DEST   0x0010 // Créé en écrasement un .BAK de la destination

// Valeurs de retour de EICCopy
#define CF_ERR_OK            0x0000 // Pas d'erreur
#define CF_ERR_DST_OVERWRITE 0x0001 // Cible déjà existante
#define CF_ERR_NO_SRC        0x0002 // Source non trouvé
#define CF_ERR_SRC_DENIED    0x0004 //   "     "  partageable en lecture
#define CF_ERR_DST_DENIED    0x0008 // Cible   "       "      "  écriture
#define CF_ERR_LOW_MEM       0x0010 // Mémoire insuffisante
#define CF_ERR_RD_SRC        0x0020 // Erreur de lecture de Source
#define CF_ERR_WR_DST        0x0040 //   "    d'écriture "  Cible
#define CF_ERR_OTHER         0x8000 // Autres erreurs (non prévues)

extern PACKAGE_EIC AnsiString __fastcall EICGetTempFileName( void);
extern PACKAGE_EIC bool     __fastcall EICDirExist( AnsiString& strPath,
                                                bool        bEndBackSlash = true);
extern PACKAGE_EIC bool     __fastcall EICLecteurDisponible(const AnsiString& strPath,bool MessageErreur = true);
extern PACKAGE_EIC bool     __fastcall EICFileExist( const AnsiString& strFilePath,                // Non/Terminé par '\\' = Fichier/Répertoire (jockers interdit),
                                                 const AnsiString& strFilePattern = EmptyStr); // Non vide (jockers autorisés) si strFilePath = Répertoire, vide si strFilePath = Fichier
extern PACKAGE_EIC void     __fastcall EICDeletePattern( const AnsiString& strFilePath,   // Avec ou sans '\\' terminal
                                                     const AnsiString& strFilePattern,
                                                     bool              bDeleteReadOnlyFiles = false);
extern PACKAGE_EIC int      __fastcall EICEnumPattern( const AnsiString&    strFilePath,     // Terminé obligatoirement par '\\'
                                                   const AnsiString&    strFilePattern,  // Jockers autorisés
                                                   ENUMPATTERN_CALLBACK pfnEnumPatternCallback,
                                                   long                 lCallbackUserData = 0); // Retourne le nb de fichiers traités par le callback
extern PACKAGE_EIC unsigned __fastcall EICCopy( const AnsiString& strNomSource,
                                            const AnsiString& strNomCible,
                                            unsigned          fCopyFlags); // Retourne une valeur CF_ERR_*


// Exceptions //
extern PACKAGE_EIC AnsiString __fastcall EICTagToStr( EICTag tag);
extern PACKAGE_EIC void       __fastcall EICThrowInvalidArgument( EICTag tag, int idsErr = IDS_EXCEPTION_INVALID_ARGUMENT, void* hInstance = HInstance);
extern PACKAGE_EIC void __fastcall EICThrowInvalidArgument(EICTag tag,const AnsiString &Texte,void *hInstance = HInstance);
extern PACKAGE_EIC AnsiString __fastcall OemToChar(const char *pcszOem);
extern PACKAGE_EIC AnsiString &__fastcall AnsiOEM(AnsiString &strAnsiDst,const char *pcszOEMSrc,DWORD dwDstMaxSzLen);
extern PACKAGE_EIC const char *__fastcall OEMAnsi(char *pszOEMDst,const AnsiString &strAnsiSrc,DWORD dwDstMaxSzLen);
extern PACKAGE_EIC AnsiString &__fastcall MACToChar(AnsiString &Chaine);
extern PACKAGE_EIC void __fastcall MACToChar(char *Chaine,unsigned int MaxLength);



class PACKAGE_EIC EUser : public Exception // Pour gérer des exceptions utilisateur contrôlées
{
 friend class ELastError;
 private:
  void*      m_hInstance;  // Instance du module qui a levé l'exception
  AnsiString m_strOrigine; // Origine de l'erreur
 public:
  __fastcall EUser( EICTag tag, const Exception&  e,      int hInstance = (int)HInstance);
  __fastcall EUser( EICTag tag, const AnsiString& strMsg = EmptyStr, int hInstance = (int)HInstance);
  __fastcall EUser( EICTag tag, const char* pcszIDSMsg,   int hInstance = (int)HInstance);
  __property void*      HInst   = { read = m_hInstance};
  __property AnsiString Origine = { read = m_strOrigine};
}; /* class EUser */

class PACKAGE_EIC ELastError : public EUser // Gère une exception en incorporant le message associé au GetLastError() actuel
{
 public:
  __fastcall ELastError( EICTag tag, const AnsiString& strMsg = EmptyStr, int hInstance = (int)HInstance);
  __fastcall ELastError( EICTag tag, const char* pcszIDSMsg,   int hInstance = (int)HInstance);
  static AnsiString __fastcall GetSysErrorMsg( DWORD dwSysErrorCode);
 private:
  void __fastcall AddLastErrorToOrigine();
}; /* class ELastError */


// Dates //
extern PACKAGE_EIC int        __fastcall DiffDateMois( const TDateTime& dtMin, const TDateTime& dtMax);
extern PACKAGE_EIC int        __fastcall DiffDateNbMois( const TDateTime &dtDate1 , const TDateTime &dtDate2);
extern PACKAGE_EIC int        __fastcall DiffDateJours( const TDateTime& dtMin, const TDateTime& dtMax, bool EnMoisDe30Jours = false);

extern PACKAGE_EIC TDateTime  __fastcall PremierJourDuMois( const TDateTime &dt);
extern PACKAGE_EIC TDateTime& __fastcall DernierJourMois( TDateTime& dt);
extern PACKAGE_EIC TDateTime& __fastcall AjouteMois( TDateTime& dt, int nNbMois);
extern PACKAGE_EIC TDateTime  __fastcall AjouteMois( const TDateTime& dt, int nNbMois);
extern PACKAGE_EIC TDateTime  __fastcall AjouteAnnees(const TDateTime &dt,int nNbAnnees);




// Gestion fichiers textes //
class PACKAGE_EIC CTextFileStream : public TFileStream // Gère un un fichier texte
{
  private:
	 bool bAddAntiSlash; 	// true pour ajouter 	le caract '\n'
	 bool bReadAntiSlash;	// true pour lire 		le caract '\n'

  public:
	__fastcall CTextFileStream(const System::AnsiString &FileName, Word Mode)
				  : TFileStream( FileName, Mode){ bAddAntiSlash=true; bReadAntiSlash = false;};
    bool __fastcall ReadLine( AnsiString &s);
  	bool __fastcall WriteLine( const AnsiString &s); // Renvoi si l'écriture s'est bien passée

    __property bool ReadCarriageReturn = { read=bReadAntiSlash, write=bReadAntiSlash };
    __property bool WriteCRLF          = { read=bAddAntiSlash , write=bAddAntiSlash  };
}; /* class CTextFileStream */

//Fonctions d'arrondit
extern PACKAGE_EIC long __fastcall lArrond( double d); //Arrondit un double en long le plus proche
extern PACKAGE_EIC double __fastcall dArrond( double d); //Arrondit un double en double le plus proche à 2 décimals (ex : 12.155 -> 12.16)
extern PACKAGE_EIC double __fastcall Round(double x, int nDecimales);

extern PACKAGE_EIC bool __fastcall CopierRepertoire(const AnsiString &RepertoireSource,const AnsiString &RepertoireDestination,TStringList *ListeFichiersSauf,TStringList *ListeRepertoiresSauf,bool ForcerAToutCopier);
extern PACKAGE_EIC bool __fastcall CopierFichier(const AnsiString &FichierSource,const AnsiString &FichierDestination);

extern PACKAGE_EIC AnsiString __fastcall RemoveAccents( const AnsiString &strText);

//Double les simples cotes de la chaine. Utilisé lorsque l'on utilise une chaine dans un filtre
extern PACKAGE_EIC AnsiString __fastcall BitA0(const AnsiString &Champ,unsigned int NoBit);
extern PACKAGE_EIC AnsiString __fastcall BitA1(const AnsiString &Champ,unsigned int NoBit);

enum eRACCOURCI
{
  er_CREATION,
  er_LECTURE,
};
class PACKAGE_EIC STRUCT_RACCOURCI
{
public:
  AnsiString      asPathOrigine;       // chemin du fichier réel
  AnsiString      asPathRaccourci;     // chemin du raccourci
  AnsiString      asDescription;       // description
  AnsiString      asLigneDeCommande;   // ligne de commande
  unsigned short  uHotKey;             // touche de raccourci
  AnsiString      asIconLocation;      // chemin de l'icone
  int             iIconLocation;       // index de l'icone
  AnsiString      asWorkingDirectory;  // repertoire de travail
  WIN32_FIND_DATA strData;             // information sur le fichier source (seulement lors d'une lecture d'un raccourci)
  __fastcall STRUCT_RACCOURCI();
};
extern PACKAGE_EIC bool __fastcall CreerRaccourci(STRUCT_RACCOURCI &Raccourci,enum eRACCOURCI uFonction = er_CREATION);// gestion des racourcis

//Ajoute une ligne dans fichier
extern PACKAGE_EIC void __fastcall WriteLog(const AnsiString &aFileName, const AnsiString &aChaine);

extern PACKAGE_EIC bool __fastcall EICSplitAbsolutePath( const AnsiString &strAbsolutePath, AnsiString &strRootName,
                                                     AnsiString       &strAbsoluteRootDir, AnsiString &strOptionalFileName);

extern PACKAGE_EIC bool __fastcall EICGetFreeSpace( const AnsiString &strAbsolutePath, unsigned __int64 &u64FreeSpace);
extern PACKAGE_EIC bool __fastcall VerInternetExplorerSup3();
extern PACKAGE_EIC bool __fastcall IsAdmin();

extern PACKAGE_EIC AnsiString __fastcall GetUniqueFileName( const AnsiString &strPath, const AnsiString &strPrefix, const AnsiString &strExt);
extern PACKAGE_EIC AnsiString __fastcall RedirectPathForCreateFile(const AnsiString &asPath);
extern PACKAGE_EIC double __fastcall EICStr2Double( const AnsiString &strValue);
extern PACKAGE_EIC Currency __fastcall EICStr2Currency( const AnsiString &strValue);
extern PACKAGE_EIC AnsiString __fastcall EICMontantToChaine(const Currency &Montant);
extern PACKAGE_EIC AnsiString __fastcall EICMontantToChaine(const double &Montant);
PACKAGE_EIC void __fastcall EncryptPassword( const AnsiString &strPassword, char *szBuffer);
PACKAGE_EIC AnsiString __fastcall DecryptPassword( char *szBuffer);

//---------------------------------------------------------------------------
//Ajoute des / ou \ en fin de chaine
//---------------------------------------------------------------------------
extern PACKAGE_EIC AnsiString AddSlash( const AnsiString &_asChaine);

extern PACKAGE_EIC AnsiString __fastcall PremierFichierLibre(const AnsiString &Fichier);

//Teste si un n° SIRET est correct
extern PACKAGE_EIC bool __fastcall     EstUnSIRET( const AnsiString &strSIRET);
extern "C"         int  _export _cdecl EstUnSIRETC(const char* pszSiret);
//Renvoie true si le SIRET est correct ou si l'utilisateur confirme la saisie d'un SIRET faux
extern PACKAGE_EIC bool __fastcall     VerificationDuSIRET( const AnsiString &strSIRET);
extern "C"         int  _export _cdecl VerificationDuSIRETC(const char* pszSiret);


//Découpe une chaîne en plusieurs éléments, chaque élément devant être délimité par un point-virgule.
extern PACKAGE_EIC void __fastcall SemicolonTextToStringList(const AnsiString &aSemiColonText, TStringList *slTexte);

//Passe l'image en Monochrome pour une utilisation en tant que mask.
extern PACKAGE_EIC void __fastcall MaskBmp(Graphics::TBitmap *Bmp, TColor TransparentColor);

//Change la TransparentColor de Bmp en FondColor
extern PACKAGE_EIC void __fastcall CreerTransparenceBmp(Graphics::TBitmap *Bmp,
                                                        TColor TransparentColor,
                                                        TColor FondColor
                                                        );

template <class T> const T &Min(const T &t1,const T &t2)
{
  return t1 < t2 ? t1 : t2;
}

template <class T> const T &Max(const T &t1,const T &t2)
{
  return t1 > t2 ? t1 : t2;
}

template <class T> T Abs(const T &t)
{
  return t >= 0 ? t : -t;
}

//---------------------------------------------------------------------------
// Calcul le nombre de pixel nécessaire en fonction du la taille en PPP
extern PACKAGE_EIC int __fastcall CalculPixelPourPPP( int _nValeur, int _nConceptionPPP=96 );
//---------------------------------------------------------------------------

extern PACKAGE_EIC short __fastcall CompareVersion(AnsiString aVersion1, AnsiString aVersion2);

#include "CCurrency.h"  //Pour ne pas à avoir à l'inclure quand on utilise les CCurrency

#define VAL_NON_DNS(Valeur) ((Valeur == D_NS) ? 0 : Valeur)

#endif // EICH
